Leetcode Day 2

是的，你在倒着遍历字符串时，可以通过几种方法同时获取当前字符和上一次（即原始字符串中它右边的那个）字符。没有一个直接的内建函数能一步到位，但以下是几种优雅且常用的方法：

方法一：使用 zip 配合切片 (推荐，通用性好)

这是利用 zip 函数将两个序列对应元素打包成元组的特性。我们将反转后的字符串与其去掉第一个字符的版本进行 zip。

my_string = "hello"
reversed_s = my_string[::-1] # "olleh"

# reversed_s      -> o, l, l, e, h
# reversed_s[1:]  -> l, l, e, h
# zip 将配对 (o,l), (l,l), (l,e), (e,h)

# 在循环中，current 是当前字符，previous 是上一个处理的（即原字符串中右边的）
for current_char, previous_char in zip(reversed_s, reversed_s[1:]):
    print(f"Current: {current_char}, Previous: {previous_char}")
    # 在这里你可以同时访问 current_char 和 previous_char
    # 比如检查 current_char 是否和 previous_char 构成特定模式

# 输出:
# Current: o, Previous: l
# Current: l, Previous: l
# Current: l, Previous: e
# Current: e, Previous: h

# 注意：这个方法不会处理反转后的第一个字符 'o'，因为它没有“上一个”字符。
# 如果你需要单独处理第一个字符（即原字符串的最后一个字符），可以在循环外进行：
if my_string: # 确保字符串不为空
    first_char_in_reverse = reversed_s[0]
    print(f"Processing the first reversed character separately: {first_char_in_reverse}")
    # ... 对 first_char_in_reverse 的处理 ...

• 优点: 代码简洁，利用了 Python 内建函数，易于理解。适用于任何序列，不仅仅是字符串。
• 缺点: 需要额外创建切片（虽然通常性能影响不大）。第一个字符需要单独处理（如果需要的话）。

方法二：手动记录上一个字符 (最直观)

在循环中用一个变量显式地存储上一次迭代的字符。

my_string = "hello"
previous_char = None # 或者其他哨兵值，表示初始状态没有上一个字符

for i, current_char in enumerate(my_string[::-1]):
    if i == 0:
        print(f"Processing first reversed char: {current_char} (No previous)")
        # 对第一个字符的特殊处理（如果需要）
    else:
        print(f"Current: {current_char}, Previous: {previous_char}")
        # 在这里同时访问 current_char 和 previous_char

    # 在循环的末尾更新 previous_char，供下一次迭代使用
    previous_char = current_char

# 输出:
# Processing first reversed char: o (No previous)
# Current: l, Previous: o
# Current: l, Previous: l
# Current: l, Previous: e
# Current: e, Previous: h

• 优点: 逻辑非常清晰直接，容易理解。可以完全控制对第一个字符的处理。
• 缺点: 需要手动维护一个额外的 previous_char 变量。

方法三：使用 itertools.pairwise (Python 3.10+，最优雅)

如果你的 Python 版本是 3.10 或更高，itertools 模块提供了一个完美的工具 pairwise。

import itertools

my_string = "hello"

# pairwise(iterable) 返回一个迭代器，产生 (elem[0], elem[1]), (elem[1], elem[2]), ...
# 我们对反转后的字符串使用它
reversed_s = my_string[::-1] # "olleh"

# pairwise(reversed_s) -> ('o', 'l'), ('l', 'l'), ('l', 'e'), ('e', 'h')
for current_char, previous_char in itertools.pairwise(reversed_s):
     print(f"Current: {current_char}, Previous: {previous_char}")

# 输出:
# Current: o, Previous: l
# Current: l, Previous: l
# Current: l, Previous: e
# Current: e, Previous: h

# 同样，这个方法不包含反转后的第一个字符 'o' 的单独处理，
# 因为 pairwise 需要至少两个元素才能产生一对。
# 如果需要处理第一个字符，可以在循环前单独进行：
if my_string:
    first_char_in_reverse = reversed_s[0]
    print(f"Processing the first reversed character separately: {first_char_in_reverse}")
    # ...

• 优点: 语义清晰，代码极其简洁优雅，是专门为这种“相邻对”场景设计的。性能通常很好。
• 缺点: 需要 Python 3.10+。同样不直接处理第一个元素。

方法四：使用索引 (手动，但能访问索引)

如果你确实需要知道当前字符在原始字符串中的索引（尽管在倒序遍历时通常不直接需要），可以用 range 来倒序遍历索引。

my_string = "hello"
n = len(my_string)

# 倒序遍历索引: n-1, n-2, ..., 1 (不包括 0)
# 因为我们要访问 i+1，所以循环到 1 即可
for i in range(n - 1, 0, -1):
    current_char = my_string[i]       # 当前字符 (索引 i)
    previous_char = my_string[i - 1] # 上一个字符 (索引 i-1, 这是原字符串中左边的)
    # 注意：这里的 previous_char 是原字符串中左边的！
    # 如果你要的是倒序遍历中“上一个”处理的字符 (即原字符串右边的)
    # 那么应该是：
    current_char_in_reverse_pass = my_string[i]
    previous_char_in_reverse_pass = my_string[i+1] # 需要处理 i = n-1 的边界情况

# --- 修正为符合题目要求的版本 ---
my_string = "hello"
n = len(my_string)

if n > 0:
    # 先处理反转后的第一个字符 (原字符串最后一个)
    first_rev_char = my_string[n-1]
    print(f"Processing first reversed char: {first_rev_char} (Index {n-1})")

# 再处理剩下的，索引从 n-2 到 0
for i in range(n - 2, -1, -1):
    current_char = my_string[i]             # 当前字符 (索引 i)
    previous_char_processed = my_string[i+1] # 上一次处理的字符 (索引 i+1)
    print(f"Current: {current_char} (Index {i}), Previous Processed: {previous_char_processed} (Index {i+1})")

# 输出:
# Processing first reversed char: o (Index 4)
# Current: l (Index 3), Previous Processed: o (Index 4)
# Current: l (Index 2), Previous Processed: l (Index 3)
# Current: e (Index 1), Previous Processed: l (Index 2)
# Current: h (Index 0), Previous Processed: e (Index 1)

• 优点: 可以直接访问原始索引。
• 缺点: 代码相对复杂，需要仔细处理边界。容易混淆“上一个处理的字符”和“索引-1的字符”。

总结推荐:

• 首选: 如果你在 Python 3.10+，使用 itertools.pairwise(my_string-1) 是最优雅的。
• 次选/通用: 使用 zip(reversed_s, reversed_s[1:]) 非常 Pythonic 且兼容性好。
• 备选/直观: 手动记录上一个字符 的方法逻辑清晰，适合初学者或需要完全控制第一个元素处理流程的情况。
• 避免: 除非你明确需要原始索引，否则基于索引的方法通常更繁琐且易出错。

选择哪种方法取决于你的 Python 版本、代码风格偏好以及是否需要对第一个（反转后的）字符进行特殊处理。

好的，如果你希望比较两个列表，只关心它们包含的元素种类和数量是否完全相同，而不考虑元素的排列顺序，有以下几种常用且 Pythonic 的方法：

方法一：使用 collections.Counter (推荐，适用于可哈希元素)

这是最直接、最能表达“元素及其计数相同”意图的方法。collections.Counter 是一个特殊的字典子类，用于计算可哈希对象（如数字、字符串、元组）的频率。

from collections import Counter

list1 = [1, 2, 3, 2, 1]
list2 = [3, 1, 2, 1, 2]
list3 = [1, 2, 3] # 数量不同
list4 = [1, 1, 1, 2, 3] # 1 的数量不同

# Counter 会统计每个元素出现的次数
counter1 = Counter(list1) # Counter({1: 2, 2: 2, 3: 1})
counter2 = Counter(list2) # Counter({1: 2, 2: 2, 3: 1})
counter3 = Counter(list3) # Counter({1: 1, 2: 1, 3: 1})
counter4 = Counter(list4) # Counter({1: 3, 2: 1, 3: 1})

print(f"list1 vs list2 (Counter): {counter1 == counter2}") # 输出: True
print(f"list1 vs list3 (Counter): {counter1 == counter3}") # 输出: False
print(f"list1 vs list4 (Counter): {counter1 == counter4}") # 输出: False

• 工作原理: Counter(list) 会创建一个字典，其中键是列表中的唯一元素，值是该元素在列表中出现的次数。然后，直接比较这两个 Counter 对象 (counter1 == counter2)。如果它们的键值对完全相同（即包含相同的元素，并且每个元素的计数也相同），则结果为 True。
• 优点:
  • 语义清晰，直接反映了比较元素计数的目的。
  • 通常效率很高（时间复杂度大约是 O(N)，其中 N 是列表长度）。
• 缺点:
  • 要求列表中的元素必须是可哈希 (hashable) 的。不能直接用于包含列表、字典或其他不可哈希对象的列表。

方法二：排序后比较 (适用于可排序元素)

如果两个列表包含相同的元素且数量也相同，那么将它们排序后，得到的列表必定完全相等。

list1 = [1, 2, 3, 2, 1]
list2 = [3, 1, 2, 1, 2]
list3 = [1, 2, 3]
list4 = [1, 1, 1, 2, 3]

# sorted() 函数返回一个新的排好序的列表
sorted_list1 = sorted(list1) # [1, 1, 2, 2, 3]
sorted_list2 = sorted(list2) # [1, 1, 2, 2, 3]
sorted_list3 = sorted(list3) # [1, 2, 3]
sorted_list4 = sorted(list4) # [1, 1, 1, 2, 3]

print(f"list1 vs list2 (sorted): {sorted_list1 == sorted_list2}") # 输出: True
print(f"list1 vs list3 (sorted): {sorted_list1 == sorted_list3}") # 输出: False (长度不同，所以肯定不等)
print(f"list1 vs list4 (sorted): {sorted_list1 == sorted_list4}") # 输出: False (排序后内容不同)

• 工作原理: 先使用 sorted() 函数分别对两个列表进行排序（注意 sorted() 返回新列表，不修改原列表），然后使用标准的列表相等比较 (==) 来比较这两个排序后的列表。
• 优点:
  • 直观易懂。
  • 适用于任何可排序的元素类型（即使是自定义对象，只要它们定义了比较方法）。
• 缺点:
  • 排序本身需要时间，时间复杂度通常是 O(N log N)，其中 N 是列表长度。对于非常大的列表，可能比 Counter 慢。
  • 要求列表中的元素之间必须是可比较 (comparable) 的（即支持 < 或 > 运算）。如果列表包含无法互相比较的类型（如混用数字和字符串），sorted() 会报错。

为什么不能直接比较 set？

你可能会想到用 set(list1) == set(list2)。但这是错误的，因为它忽略了元素的数量/频率。set 只关心元素是否存在，不关心它出现了多少次。

list1 = [1, 1, 2]
list2 = [1, 2, 2]

print(set(list1))        # 输出: {1, 2}
print(set(list2))        # 输出: {1, 2}
print(set(list1) == set(list2)) # 输出: True (错误！因为元素数量不同)
print(Counter(list1) == Counter(list2)) # 输出: False (正确)
print(sorted(list1) == sorted(list2)) # 输出: False (正确)

总结推荐:

• 如果你的列表元素都是可哈希的（数字、字符串、元组等），优先使用 collections.Counter，它语义最清晰且通常效率最高。
• 如果你的列表元素是可排序但不一定可哈希（比如自定义对象），或者你不确定是否可哈希，或者列表非常小，那么使用 sorted() 后比较也是一个很好的选择。

好的，你想在向列表 append 元素时，确保只有当这个元素不在列表中时才添加，从而避免重复。这里有几种常用的方法，各有优劣：

方法一：每次添加前检查 (if item not in list) - 最直观

这是最直接的想法，也易于理解。

my_list = [10, 20, 30]
items_to_add = [20, 40, 10, 50]

for item in items_to_add:
    if item not in my_list: # 检查元素是否已存在
        my_list.append(item)
        print(f"已添加: {item}")
    else:
        print(f"已存在，跳过: {item}")

print(f"最终列表: {my_list}")
# 输出:
# 已存在，跳过: 20
# 已添加: 40
# 已存在，跳过: 10
# 已添加: 50
# 最终列表: [10, 20, 30, 40, 50]

• 优点:
  • 代码非常清晰，直接表达了你的意图。
  • 保持了元素添加的原始顺序（如果顺序重要的话）。
• 缺点:
  • 效率问题: item not in my_list 操作需要遍历列表来查找元素。对于列表，这个查找的时间复杂度是 O(N)，其中 N 是列表当前的长度。如果你需要频繁地进行这种“检查并添加”的操作，并且列表变得很长，那么整体效率会比较低（可能接近 O(M*N)，M 是你要添加的元素数量）。

方法二：使用集合 (set) 辅助进行快速查找 - 效率更高

如果你需要进行大量的添加操作，并且关心效率，可以同时维护一个集合 (set) 来快速判断元素是否存在。集合的查找操作平均时间复杂度是 O(1)。

my_list = [10, 20, 30]
# 创建一个包含列表初始元素的集合，用于快速查找
existing_items_set = set(my_list)

items_to_add = [20, 40, 10, 50]

for item in items_to_add:
    # 在集合中检查是否存在 (O(1) 平均时间)
    if item not in existing_items_set:
        my_list.append(item)          # 添加到列表 (保持顺序)
        existing_items_set.add(item)  # 也添加到集合 (用于后续快速查找)
        print(f"已添加: {item}")
    else:
        print(f"已存在 (通过 set 检查)，跳过: {item}")

print(f"最终列表: {my_list}")
print(f"最终集合: {existing_items_set}")
# 输出:
# 已存在 (通过 set 检查)，跳过: 20
# 已添加: 40
# 已存在 (通过 set 检查)，跳过: 10
# 已添加: 50
# 最终列表: [10, 20, 30, 40, 50]
# 最终集合: {10, 20, 30, 40, 50}

• 优点:
  • 检查效率高: item not in existing_items_set 非常快 (O(1))。
  • 仍然保持了列表 my_list 中元素的原始添加顺序。
• 缺点:
  • 需要额外维护一个集合，占用更多内存。
  • 要求列表中的元素必须是可哈希 (hashable) 的（数字、字符串、元组等可以，列表、字典不行），因为集合需要对元素进行哈希。

方法三：最终结果使用集合去重（如果顺序不重要或可以后处理）

如果你不关心元素的添加顺序，或者可以在所有元素添加完之后再处理顺序和去重，可以直接先全部添加（或使用集合），最后再转换。

# 情况 A: 如果最终顺序无所谓，可以直接用集合
my_list = [10, 20, 30]
items_to_add = [20, 40, 10, 50]

# 直接将两者合并到集合中，自动去重
final_set = set(my_list) | set(items_to_add) # 使用集合的并集操作
# 或者
# final_set = set(my_list)
# final_set.update(items_to_add)

print(f"最终集合 (顺序丢失): {final_set}") # 输出: {10, 20, 30, 40, 50} (顺序可能不同)
# 如果需要列表形式
final_list_no_order = list(final_set)
print(f"最终列表 (顺序丢失): {final_list_no_order}")


# 情况 B: 如果需要保持原始列表顺序，并添加新元素（去重）
my_list = [10, 20, 30]
items_to_add = [20, 40, 10, 50]

existing_items_set = set(my_list) # 记录已存在的

for item in items_to_add:
    if item not in existing_items_set:
        my_list.append(item)
        existing_items_set.add(item) # 同样需要更新 set

print(f"最终列表 (保持顺序): {my_list}") # [10, 20, 30, 40, 50]

• 优点 (情况 A): 代码非常简洁。
• 缺点 (情况 A): 完全丢失了元素的原始顺序和添加顺序。
• 说明 (情况 B): 这本质上又回到了方法二。

方法四：利用字典的键保持插入顺序 (Python 3.7+)

从 Python 3.7 开始（CPython 3.6 就已经是了），字典会保持其键的插入顺序。我们可以利用这个特性来模拟一个“有序集合”。

my_list = [10, 20, 30]
items_to_add = [20, 40, 10, 50]

# 使用字典的键来存储元素，值可以任意（比如 None 或 True）
# 初始元素放入字典
ordered_unique_dict = {item: None for item in my_list}

for item in items_to_add:
    # 尝试添加，如果键已存在，字典会自动处理（保持第一次插入的位置）
    if item not in ordered_unique_dict:
        print(f"已添加: {item}")
    else:
        print(f"已存在，跳过: {item}")
    ordered_unique_dict[item] = None # 添加或更新键

# 最后从字典的键获取有序的、唯一的元素列表
final_list = list(ordered_unique_dict.keys())

print(f"最终列表: {final_list}")
# 输出:
# 已存在，跳过: 20
# 已添加: 40
# 已存在，跳过: 10
# 已添加: 50
# 最终列表: [10, 20, 30, 40, 50]

• 优点:
  • 结合了 O(1) 的平均查找/添加效率和保持插入顺序的特性。
  • 只用了一个主要的数据结构（字典）。
• 缺点:
  • 依赖于 Python 3.7+ 的字典特性（虽然现在很普遍了）。
  • 稍微有点“绕”，可能不如方法一或方法二直观。
  • 同样要求元素是可哈希的。

总结推荐：

• 如果列表不大，或者添加操作不频繁： 方法一 (直接检查 if item not in my_list) 最简单明了。
• 如果效率很重要，且列表很大或添加频繁，并且元素可哈希： 方法二 (使用辅助 set) 是最佳选择，平衡了效率和顺序保持。
• 如果最终顺序不重要，且元素可哈希： 直接使用 set 操作（方法三 A）最简洁。
• 如果你使用的是现代 Python (3.7+)，且元素可哈希： 方法四 (利用字典键) 提供了一个只用一个数据结构就能兼顾效率和顺序的优雅方案。

根据你的具体需求（列表大小、添加频率、是否需要保持顺序、元素类型）来选择最合适的方法。